Hi. Recently I talked with Richard Stallman. He told me you had some interest in the FSF's Objective C compiler.
You may be aware that the FSF's compiler does not contain a run time library. I wrote one and donated it to the FSF. It still requires some work but does make the objects go. It is modeled after NeXT's (2.2) run time and is equal in speed. I have volunteered to be the FSF's Objective C anything person.
Are you interested in this and, who are you?
---
Dennis P. Glatting
Sr. Technical Manager
Trirex Systems Inc.
315 Post Road West
Westport, Connecticut 06880
203-221-4614
203-221-4602 (fax)
dennis_glatting@trirex.com
NeXTmail Ok.
Newsgroups: comp.sys.next.misc
From: mmelling@Trirex.com(Michael Mellinger)
Subject: Re: Do you want free objects from FSF?
Organization: Trirex Systems Inc.
Date: Mon, 24 Aug 1992 04:10:37 GMT
In article <59776@mimsy.umd.edu> alex@cs.umd.edu (Alex Blakemore) writes:
> In article <Bt8A6G.JuI@world.std.com> gsk@world.std.com (Geoffrey S
Knauth) writes:
> > Would you like to see free objects, libraries, palettes, toolkits,
> > etc., from the Free Software Foundation?
>
> Its a great idea that would benefit the whole community, including
> app developers and NeXT Inc. There is a an unsatisfied precondition
though.
> The Free Object Foundation needs a FSF Objective C runtime for gcc.
> Is anyone working on one?
Yes, Dennis Glatting an employee here at Trirex wrote one. It will be on
the NeXT educational CD ROM. Hopefully, Trirex will be donating more
objects, utilities, etc. to the NeXT community. In fact, Dennis is hard
at work on a Find object that supports regular expressions. He's not
screaming as much as he was early this evening, so I think he's making
progress. :-)
-Mike
Newsgroups: comp.lang.objective-c
From: dglattin@trirex.com (Dennis Glatting)
Subject: Re: PD Implementation?
Date: Thu, 27 Aug 1992 20:56:58 GMT
In article <alain.3266@charpe.UUCP> alain@charpe.UUCP (Alain Charpentier)
writes:
>
> His anybody aware of some one work on the runtime for GNU.
> And to they need help.
Yes.
A Objective C run time has been donated to the Free Software Foundation.
It includes the dispatcher and Object class. The run time is portable and
equivalent in speed to the dispatcher found in NeXT's OS2.2 (overhead of
3).
There is some clean up work I need to do to the initialization code and
some minor changes to the compiler. At the moment I'm under a time
crunch. Soon, soon, ...
--
Dennis P. Glatting / Sr. Technical Manager / Trirex Systems Inc.
315 Post Road West / Westport, Connecticut 06880 / (203)221-4600
dennis_glatting@trirex.com (NeXTmail Ok)
Member League for Programming Freedom
Date: Thu, 3 Sep 92 00:06 PDT
From: michael@stb.info.com (Michael Gersten)
To: ucla-cs!marble.com!gsk@cs.ucla.edu
Subject: Obj C system
The real question is not, is the performance comparable to Next's objective C. The real question is, is it compatible.
Will it support pose as, dynamic loading, etc.
Will it be possible to send remote messages between a gnu obj C and a Next obj C program?
Will it be possible to take a .o file produced by the next obj C compiler, and dynamic load it into a gnu obj C program? Visa/versa?
Is it thread safe, or can it be told to be thread safe? (The issue here is updating the method cache when a new method is added. Next 2.0, for example, is not thread safe, but 3.0 can be told to enable locking (it is off by default).)
--
Michael Gersten michael@stb.info.com
HELLO! I'm a signature virus! Join in the fun and copy me into yours!
ex:.-1,. w $HOME/.signature
Date: Tue, 8 Sep 92 19:35:33 -0400
From: Dennis Glatting <dglattin@trirex.com>
To: michael@stb.info.com (Michael Gersten)
Subject: Obj C system, questions
Cc: <uunet!marble.com!gsk@uunet.uu.net>
> The real question is not, is the performance comparable
> to Next's objective C. The real question is, is it
> compatible.
It is compatible in some respests but not others. For example, posing is supported but forwarding is not. Archiving objects is supported but types streams are not. +new is the factory method that creates objects not +alloc.
The run time is in its infancy and some of its goals are different than the NeXT or Stepstone implementation. For example, portability is a key goal.
> Will it support pose as, dynamic loading, etc.
Posing is supported but dynamic loading is not implemented at this time. GNU dynamic loading would probably be built upon BFD. Would you like to write that portion of the package?
> Will it be possible to send remote messages between a gnu
> obj C and a Next obj C program?
I believe NeXT "remote messages" are based upon Mach messaging and therefore unavailable under SunOS, AIX, etc. Is your question more of one where you are mixing objects on the same platform or across platforms?
> Will it be possible to take a .o file produced by the next
> obj C compiler, and dynamic load it into a gnu obj C
> program? Visa/versa?
>
> Is it thread safe, or can it be told to be thread safe? (The
> issue here is updating the method cache when a new method
> is added. Next 2.0, for example, is not thread safe, but
> 3.0 can be told to enable locking (it is off by default).)
Currently the run time is not thread safe but it is planned. It isn't a difficult thing to do.
---
Dennis P. Glatting / Sr. Technical Manager / Trirex Systems Inc.
315 Post Road West / Westport, Connecticut 06880 / (203)221-4600
dennis_glatting@trirex.com (NeXTmail Ok)
Member League for Programming Freedom
Date: Fri, 18 Sep 92 06:38:07 -0700
From: Dennis Glatting <seattle-ni-srvr!dglattin@trirex.com>
To: Bruce Nilo <uunet!ictv.com!bruce@uunet.uu.net>
Subject: Protocols, Reflection...objc_msgSend()
Cc: gnu-objc@prep.ai.mit.edu
> I think that the ability to override objc_msgSend is just
> one aspect of the general desire to be able to specialize
> various runtime behaviors. CLOS provides something
> called the meta object kernel which enables advanced
> programmers to customize the the language itself to the
> point that the default semantics becomes something
> entirely different.
How is this different than posing as Object or adding category methods?
> A prior suggestion was made that ideally the runtime
> should be object oriented. In my experience this is quite
> doable and, if done, provides a straight forward means to
> override a whole host of behaviors from message dispatch
> to instance variable lookup. Moreover this behavior
> would be customized on a per class basis as opposed to
> globally. New "root" objects could be selectively
> implemented each overriding default low level runtime
> behaviors defined in Object.
Origionally, the GNU run time was written in C++.
-dpg
Date: Fri, 18 Sep 92 06:08:24 -0700
From: Dennis Glatting <seattle-ni-srvr!dglattin@trirex.com>
To: ucla-cs!prep.ai.mit.edu!gnu-objc@cs.ucla.edu
Subject: Re: Automatic input/output, persistence
Reply-To: dennis_glatting@trirex.com
> > A key difference between the NeXT and StepStone
> > foundation class libraries is the latter supports a much
> > more convenient scheme for storing objects to and
> > reading them back from files. The NeXT version, as I
> > understand it (I don't have a NeXT; I have a Sun running
> > Stepstone's version), only supports what I would call
> > "semi-automatic" input/output--that is, the
> > implementor of each subclass must implement methods to
> > archive objects of this subclass. The Stepstone library
> > does not require any new implementation at all. If your
> > object is a subclass of Stepstone's Object, it
> > input/output--providing you explicitly link in the
> > relevant code.
> >
>
> Doesn't this break the concept of encapsulation?
> Shouldn't the object itself be responsible for what it
> contains and what is relevant rather than an outside
> entity? How does one automatically store a void*?
>
> -dpg
> ------
> Not at all. Just as every object inherits some default
> behavior, and can override it if they need to, so everyone
> can inherit some default "here's how to write yourself to
> a file" method. If it is really a problem, you can override
> it.
Well, that follows the NeXT principals.
> Besides, what *CAN* you do with a void? If you mean a void *,
> you'd have to write some special casing, but meanwhile
> you can say [super archive:self] to get the rest of the
> object written, and then just write out whatever your
> void * is pointing to.
I did say void*. What is pointed to by the void* is known only by the class itself and whether it is relevant -- as it should be. Just as I could say [super archive:self], I can also say [super write:aStream].
>> I think that the ability to override objc_msgSend is just
>> one aspect of the general desire to be able to specialize
>> various runtime behaviors. CLOS provides something
>> called the meta object kernel which enables advanced
>> programmers to customize the the language itself to the
>> point that the default semantics becomes something
>> entirely different.
>How is this different than posing as Object or adding category >methods?
The runtime behaviors which I am referring to are behaviors which
are not acessible in Object. For example, looking up and setting
instance variables has a well defined semantics in Objective C. However, if I wanted another semantics, say one which added a dynamic versioning capability to instance variable access and mutation, adding category methods or posing as Object would not help me much. The example I referred to above is method invocation. Again if internal runtime behaviors were overridable I could easily define
more involved method dispatch semantics.
>> A prior suggestion was made that ideally the runtime
>> should be object oriented. In my experience this is quite
>> doable and, if done, provides a straight forward means to
>> override a whole host of behaviors from message dispatch
>> to instance variable lookup. Moreover this behavior
>> would be customized on a per class basis as opposed to
>> globally. New "root" objects could be selectively
>> implemented each overriding default low level runtime
>> behaviors defined in Object.
> Origionally, the GNU run time was written in C++.
What I really meant to say was that the runtime could be implemented
meta-circularly. In other words Object could implement the
run time behavior of Objective C via methods defined by Object.
